home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume8 / se / part01 next >
Encoding:
Internet Message Format  |  1987-01-25  |  54.2 KB
  1. Subject:  v08i001:  Georgia Tech 'se' Screen Editor
  2. Newsgroups: mod.sources
  3. Approved: mirror!rs
  4.  
  5. Submitted by: emoryu1!arnold (Arnold D. Robbins)
  6. Mod.sources: Volume 8, Issue 1
  7. Archive-name: se/Part01
  8.  
  9.  
  10. Here is the second release of the Georgia Tech Screen Editor, 'se'.
  11. There were enough changes that a whole new posting is warranted.
  12.  
  13. Major Changes:
  14.     All Georgia Tech specific stuff removed.
  15.     It understands window size changes on 4.3BSD and ATT Unix PC/3B1
  16.     Support for the shared library on the ATT Unix PC/3B1
  17.     Considerable source code reorganization in certain files.
  18.  
  19. Enjoy,
  20.  
  21. Arnold Robbins
  22.  
  23. #! /bin/sh
  24. # This is a shell archive, meaning:
  25. # 1. Remove everything above the #! /bin/sh line.
  26. # 2. Save the resulting text in a file.
  27. # 3. Execute the file with /bin/sh (not csh) to create the files:
  28. #    README
  29. #    ascii.h
  30. #    constdefs.h
  31. #    docmd1.c
  32. #    docmd2.c
  33. export PATH; PATH=/bin:$PATH
  34. echo shar: extracting "'README'" '(6131 characters)'
  35. if test -f 'README'
  36. then
  37.     echo shar: will not over-write existing file "'README'"
  38. else
  39. cat << \SHAR_EOF > 'README'
  40. # 
  41. # $Header: README,v 1.3 86/07/17 17:52:23 arnold Exp $
  42. # 
  43. # $Log:    README,v $
  44. # Revision 1.3  86/07/17  17:52:23  arnold
  45. # Fixed some spelling mistakes.
  46. # 
  47. # Revision 1.2  86/07/17  17:19:06  arnold
  48. # Removed GT specific stuff, added discussion of window sensitivities.
  49. # 
  50. # Revision 1.1  86/05/06  13:34:09  osadr
  51. # Initial revision
  52. # 
  53. # 
  54. # 
  55. README:
  56.  
  57. This directory contains the source files for the Unix version of the Georgia
  58. Tech Screen Editor "Se".  It has three subdirectories which contain things
  59. that se needs. Here is a rundown of the various files.
  60.  
  61. Files containing documentation are:
  62.  
  63. README        -- this file.
  64. se.m4        -- nroff manual page for se (has to be munged to create se.1).
  65. scriptse.1    -- nroff manual page for scriptse.
  66.  
  67. The header files are:
  68.  
  69. ascii.h        -- definition of ASCII mnemonics and control characters.
  70. extern.h    -- external data definitions for the screen editor.
  71. se.h        -- global #define's for the screen editor.
  72. constdefs.h    -- global constants, also used by files in subdirectories.
  73.  
  74. The C source files are:
  75.  
  76. main.c        -- main program and declaration of globals, initialization.
  77. edit.c        -- main command loop to get and execute commands, file handling.
  78. docmd1.c    -- command decoder and functions for most commands.
  79. docmd2.c    -- functions for the rest of the commands.
  80. misc.c        -- miscellanious functions.
  81. scratch.c    -- scratch file manipulating functions.
  82. screen.c    -- routines to keep track of the screen contents.
  83. term.c        -- routines for changing the terminal.
  84.  
  85. The subdirectories are:
  86.  
  87. libchangetty    -- routines to change the terminal driver back and forth.
  88. pat        -- pattern matching routines.
  89. se_h        -- contains help scripts for all commands in se.
  90.  
  91. Miscellanious files:
  92.  
  93. where        -- shell file to determine System V (R 1 or 2), 4.1, or 4.2 BSD.
  94. m4munge        -- manipulate output of where for m4 for se man page
  95. makefile    -- the makefile for make(1).
  96. print2        -- inode used by make for printing only changed stuff.
  97.  
  98. scriptse.c    -- quick and dirty C program to make scripts for se.
  99. scriptse.1    -- manual page for same.
  100.  
  101. Executable files:
  102.  
  103. se        -- executable version of the screen editor.
  104. scriptse    -- the executable version of the script maker.
  105.  
  106.  
  107. Conditional Compilation flags:
  108.  
  109.     The flag HARD_TERMS, if added to the CFLAGS macro in the makefile,
  110. will remove the terminal-independent code which uses termlib, and put back
  111. the original, terminal-types-hardwired-into-the-program code.  The only
  112. reason to do this is if se has to run on a system without the termlib package.
  113. Using termlib, se is considerably smaller, as well as more flexible.
  114.  
  115.     The flag OLD_SCRATCH, if added to the CFLAGS macro in the makefile,
  116. will cause se to use the original, linked-list method for keeping track of
  117. lines in the buffer.  This method is faster for rearranging lines, but
  118. considerably slower for simply looking up lines.  Currently, se uses the
  119. method given in Software Tools in Pascal, which keeps the lines in order in
  120. an array.  It is slower at rearranging, but as fast as possible for finding
  121. lines in the buffer.  This version also takes less data and code space.
  122.  
  123.     The flag OLD_GLOB, if added to the CFLAGS macro in the makefile,
  124. will keep se from special casing commands whose effect is to reverse the
  125. order of the lines in the buffer.  The special casing code can save an
  126. *incredible* amount of time for this pathological case, so it is best to leave
  127. things alone.  This only applies to the Software Tools in Pascal style
  128. line handling.
  129.  
  130.     The flag LOG_USAGE, if added to the CFLAGS macro in the makefile,
  131. will cause se to write usage "statistics" to a log file, consisting of the
  132. login name and time and date when an individual used se. The logfile path
  133. name in the log() routine in edit.c should be changed to use a system
  134. accounting file somewhere.  It currently creates a file in /usr/tmp.
  135.  
  136.     The 'where' command creates a file called 'flags', which the makefile
  137. cats inside ``s.  These define and/or undefine the flags USG for System V,
  138. S5R2 if for Release 2, BSD for 4.1 and 4.2, and BSD4_2 for 4.2 specific code.
  139.  
  140. Miscellanious:
  141.  
  142.     Code which is dependent on the Berkeley job control stuff is also
  143. conditionally compiled in, so that on systems without it, it won't get in
  144. the way.
  145.  
  146.     Code has been added which should allow se to come up under USG Unix
  147. 5.0 (System V).  If S5R2 is defined, se will use the terminfo package.
  148. Otherwise, it assumes Release 1, and that the BSD termlib package has
  149. been ported and is available.
  150.  
  151.     There is code in term.c to test if se is running on a system with
  152. windows or not. It currently understands the windows on an ATT Unix PC (or 3B1)
  153. and the windowing ioctl's in BRL Unix, which should be identical to those
  154. in 4.3 BSD.
  155.  
  156. Comments:
  157.  
  158.     It is a big piece of software. But, if you 1) read both Software Tools
  159. and Software Tools in Pascal (the chapters on editing and pattern matching, if
  160. you don't want to read all of the books), and 2) take your time, you should be
  161. able to understand, and eventually make changes to it, as necessary.
  162.  
  163. Authors:
  164.  
  165.     Se started out as the version of 'ed' that came with the book 'Software
  166. Tools', by Kernighan and Plauger, which was written in Ratfor. On the Pr1me
  167. computers at the School of Information and Computer Science at Georgia Tech,
  168. Dan Forsyth, Perry Flinn, and Alan Akin added all the enhancements suggested
  169. in the exercises in the book, and some more of their own. Jack Waugh made
  170. extensive modifications to turn it into a screen editor; further work was done
  171. by Dan Forsyth. All of this was in an improved Georgia Tech version of Ratfor.
  172.  
  173.     Later, Dan Forsyth, then (and now) at Medical Systems Development
  174. Corporation, converted the Ratfor version into C, for Berkeley Unix (4.1 BSD).
  175. At Georgia Tech, Arnold Robbins took the C version and added many new features
  176. and improvements, the most important of which was termcap support and System V
  177. support. The existing help screens were edited and completed at that time, as
  178. well. This was completed in early 1985.
  179.  
  180.     Arnold Robbins is now at ...!gatech!emory!arnold, and will make every
  181. reasonable attempt to answer any questions anyone may have about it, but in
  182. no way promises to support or enhance 'se'.
  183. SHAR_EOF
  184. fi # end of overwriting check
  185. echo shar: extracting "'ascii.h'" '(1389 characters)'
  186. if test -f 'ascii.h'
  187. then
  188.     echo shar: will not over-write existing file "'ascii.h'"
  189. else
  190. cat << \SHAR_EOF > 'ascii.h'
  191. /*
  192.  * $Header: ascii.h,v 1.1 86/05/06 13:35:19 osadr Exp $
  193.  */
  194.  
  195. /*
  196.  * $Log:    ascii.h,v $
  197.  * Revision 1.1  86/05/06  13:35:19  osadr
  198.  * Initial revision
  199.  * 
  200.  * 
  201.  */
  202.  
  203. /*
  204. ** ascii.h
  205. **
  206. ** definitions of ASCII mnemonics and synonyms.
  207. */
  208.  
  209. #ifndef    _ASCII_H
  210. #define    _ASCII_H
  211. #define    NUL    '\0'
  212. #define    SOH    '\001'
  213. #define    STX    '\002'
  214. #define    ETX    '\003'
  215. #define    EOT    '\004'
  216. #define    ENQ    '\005'
  217. #define    ACK    '\006'
  218. #define    BEL    '\007'
  219. #define    BS    '\010'
  220. #define    HT    '\011'
  221. #define    LF    '\012'
  222. #define    VT    '\013'
  223. #define    FF    '\014'
  224. #define    CR    '\015'
  225. #define    SO    '\016'
  226. #define    SI    '\017'
  227. #define    DLE    '\020'
  228. #define    DC1    '\021'
  229. #define    DC2    '\022'
  230. #define    DC3    '\023'
  231. #define    DC4    '\024'
  232. #define    NAK    '\025'
  233. #define    SYN    '\026'
  234. #define    ETB    '\027'
  235. #define    CAN    '\030'
  236. #define    EM    '\031'
  237. #define    SUB    '\032'
  238. #define    ESC    '\033'
  239. #define    FS    '\034'
  240. #define    GS    '\035'
  241. #define    RS    '\036'
  242. #define    US    '\037'
  243. #define    SP    '\040'
  244. #define    DEL    '\177'
  245. #define    CTRL_A    SOH
  246. #define    CTRL_B    STX
  247. #define    CTRL_C    ETX
  248. #define    CTRL_D    EOT
  249. #define    CTRL_E    ENQ
  250. #define    CTRL_F    ACK
  251. #define    CTRL_G    BEL
  252. #define    CTRL_H    BS
  253. #define    CTRL_I    HT
  254. #define    CTRL_J    LF
  255. #define    CTRL_K    VT
  256. #define    CTRL_L    FF
  257. #define    CTRL_M    CR
  258. #define    CTRL_N    SO
  259. #define    CTRL_O    SI
  260. #define    CTRL_P    DLE
  261. #define    CTRL_Q    DC1
  262. #define    CTRL_R    DC2
  263. #define    CTRL_S    DC3
  264. #define    CTRL_T    DC4
  265. #define    CTRL_U    NAK
  266. #define    CTRL_V    SYN
  267. #define    CTRL_W    ETB
  268. #define    CTRL_X    CAN
  269. #define    CTRL_Y    EM
  270. #define    CTRL_Z    SUB
  271. #endif
  272. SHAR_EOF
  273. fi # end of overwriting check
  274. echo shar: extracting "'constdefs.h'" '(325 characters)'
  275. if test -f 'constdefs.h'
  276. then
  277.     echo shar: will not over-write existing file "'constdefs.h'"
  278. else
  279. cat << \SHAR_EOF > 'constdefs.h'
  280. /*
  281.  * $Header: constdefs.h,v 1.1 86/05/06 13:35:37 osadr Exp $
  282.  */
  283.  
  284. /*
  285.  * $Log:    constdefs.h,v $
  286.  * Revision 1.1  86/05/06  13:35:37  osadr
  287.  * Initial revision
  288.  * 
  289.  * 
  290.  */
  291.  
  292. /*
  293. ** constdefs.h
  294. **
  295. ** Standard macro definitions for se screen editor
  296. */
  297.  
  298. #define    EOS '\0'
  299. #define    ERR (-3)
  300. #define    OK (-2)
  301. #define    NO 0
  302. #define    YES 1
  303. SHAR_EOF
  304. fi # end of overwriting check
  305. echo shar: extracting "'docmd1.c'" '(27523 characters)'
  306. if test -f 'docmd1.c'
  307. then
  308.     echo shar: will not over-write existing file "'docmd1.c'"
  309. else
  310. cat << \SHAR_EOF > 'docmd1.c'
  311. #ifndef lint
  312. static char RCSid[] = "$Header: docmd1.c,v 1.3 86/07/17 17:19:37 arnold Exp $";
  313. #endif
  314.  
  315. /*
  316.  * $Log:    docmd1.c,v $
  317.  * Revision 1.3  86/07/17  17:19:37  arnold
  318.  * Some general code cleaning up.
  319.  * 
  320.  * Revision 1.2  86/07/11  15:10:20  osadr
  321.  * Removed Georgia Tech specific items.
  322.  * 
  323.  * Revision 1.1  86/05/06  13:36:44  osadr
  324.  * Initial revision
  325.  * 
  326.  * 
  327.  */
  328.  
  329. /*
  330. ** docmd1.c
  331. **
  332. ** main command processor.  routines for individual commands
  333. */
  334.  
  335. #include "se.h"
  336. #include "extern.h"
  337.  
  338. /* static data definitions -- variables only needed in this file */
  339. static char Tlpat[MAXPAT] = "";    /* saved character list for y/t command */
  340. static char Tabstr[MAXLINE] = "";    /* string representation of tab stops */
  341. static char Ddir = FORWARD;        /* delete direction */
  342. static int Compress;            /* compress/expand tabs on read/write */
  343.  
  344. /* docmd --- handle all commands except globals */
  345.  
  346. int docmd (lin, i, glob, status)
  347. char lin[];
  348. int i, glob, *status;
  349. {
  350.     char file[MAXLINE], sub[MAXPAT];
  351.     char kname;
  352.     int gflag, line3, pflag, flag, fflag, junk, allbut, tflag;
  353.     int append (), ckchar (), ckp (), ckupd (), copy ();
  354.     int delete (), domark (), doopt (), doprnt (), doread ();
  355.     int doshell ();
  356.     int dotlit (), doundo (), dowrit (), getfn (), getkn ();
  357.     int getone (), getrange (), getrhs (), getstr (), inject ();
  358.     int join (), makset (), move (), nextln (), optpat ();
  359.     int prevln (), substr (), draw_box ();
  360.     char *expand_env ();
  361.  
  362.  
  363.     *status = ERR;
  364.     if (intrpt ())  /* catch a pending interrupt */
  365.         return (*status);
  366.  
  367.     switch (lin[i]) {
  368.     case APPENDCOM:
  369.     case UCAPPENDCOM:
  370.         if (lin[i + 1] == '\n' || lin[i + 1] == ':')
  371.         {
  372.             defalt (Curln, Curln);
  373.             if (lin[i + 1] == '\n')
  374.             {
  375.                 /* avoid updating with inline insertion */
  376.                 adjust_window (Line1, Line2);
  377.                 updscreen ();
  378.             }
  379.             *status = append (Line2, &lin[i + 1]);
  380.         }
  381.         break;
  382.  
  383.     case PRINTCUR:
  384.         if (lin[i + 1] == '\n')
  385.         {
  386.             defalt (Curln, Curln);
  387.             saynum (Line2);
  388.             *status = OK;
  389.         }
  390.         break;
  391.  
  392.     case OVERLAYCOM:
  393.     case UCOVERLAYCOM:
  394.         defalt (Curln, Curln);
  395.         if (lin[i + 1] == '\n')
  396.             overlay (status);
  397.         break;
  398.  
  399.     case CHANGE:
  400.     case UCCHANGE:
  401.         defalt (Curln, Curln);
  402.         if (Line1 <= 0)
  403.             Errcode = EORANGE;
  404.         else if (lin[i + 1] == '\n' || lin[i + 1] == ':')
  405.         {
  406.             if (lin[i + 1] == '\n')
  407.             {
  408.                 /* avoid updating with inline insertion */
  409.                 adjust_window (Line2, Line2);
  410.                 updscreen ();
  411.             }
  412.             First_affected = min (First_affected, Line1);
  413.             if (lin[i + 1] == '\n')
  414.                 warn_deleted (Line1, Line2);
  415.             *status = append (Line2, &lin[i + 1]);
  416.             if (*status != ERR)
  417.             {
  418.                 line3 = Curln;
  419.                 delete (Line1, Line2, status);
  420.                 Curln = line3 - (Line2 - Line1 + 1);
  421.                 /* adjust for deleted lines */
  422.             }
  423.         }
  424.         break;
  425.  
  426.     case DELCOM:
  427.     case UCDELCOM:
  428.         if (ckp (lin, i + 1, &pflag, status) == OK)
  429.         {
  430.             defalt (Curln, Curln);
  431.             if (delete (Line1, Line2, status) == OK
  432.                 && Ddir == FORWARD
  433.                 && nextln (Curln) != 0)
  434.                 Curln = nextln (Curln);
  435.         }
  436.         break;
  437.  
  438.     case INSERT:
  439.     case UCINSERT:
  440.         defalt (Curln, Curln);
  441.         if (Line1 <= 0)
  442.             Errcode = EORANGE;
  443.         else if (lin[i + 1] == '\n' || lin[i + 1] == ':')
  444.         {
  445.             if (lin[i + 1] == '\n')
  446.             {
  447.                 /* avoid updating with inline insertion */
  448.                 adjust_window (Line1, Line2);
  449.                 updscreen ();
  450.             }
  451.             *status = append (prevln (Line2), &lin[i + 1]);
  452.         }
  453.         break;
  454.  
  455.     case MOVECOM:
  456.     case UCMOVECOM:
  457.         i++;
  458.         if (getone (lin, &i, &line3, status) == EOF)
  459.             *status = ERR;
  460.         if (*status == OK && ckp (lin, i, &pflag, status) == OK)
  461.         {
  462.             defalt (Curln, Curln);
  463.             *status = move (line3);
  464.         }
  465.         break;
  466.  
  467.     case COPYCOM:
  468.     case UCCOPYCOM:
  469.         i++;
  470.         if (getone (lin, &i, &line3, status) == EOF)
  471.             *status = ERR;
  472.         if (*status == OK && ckp (lin, i, &pflag, status) == OK)
  473.         {
  474.             defalt (Curln, Curln);
  475.             *status = copy (line3);
  476.         }
  477.         break;
  478.  
  479.     case SUBSTITUTE:
  480.     case UCSUBSTITUTE:
  481.         i++;
  482.         if (lin[i] == '\n')
  483.         {
  484.             /* turn "s\n" into "s//%/\n" */
  485.             lin[i+0] = '/';
  486.             lin[i+1] = '/';
  487.             lin[i+2] = '%';
  488.             lin[i+3] = '/';
  489.             lin[i+4] = '\n';
  490.             lin[i+5] = EOS;
  491.             Peekc = SKIP_RIGHT;
  492.         }
  493.         else
  494.         {
  495.             /* try to handle "s/stuff\n" */
  496.             int j, missing_delim;
  497.  
  498.             missing_delim = YES;
  499.             for (j = i + 1; lin[j] != '\n'; j++)
  500.                 if (lin[j] == ESCAPE && lin[j+1] == lin[i])
  501.                     j++;    /* skip esc, loop continues */
  502.                 else if (lin[j] == lin[i])
  503.                 {
  504.                     missing_delim = NO;
  505.                     break;    /* for */
  506.                 }
  507.  
  508.             if (missing_delim)
  509.             {
  510.                 for (; lin[j] != EOS; j++)
  511.                     ;
  512.                 j--;        /* j now at newline */
  513.  
  514.                 lin[j] = lin[i];    /* delim */
  515.                 lin[++j] = '\n';
  516.                 lin[++j] = EOS;
  517.                 Peekc = SKIP_RIGHT;
  518.                 /* rest of routines will continue to fix up */
  519.             }
  520.         }
  521.  
  522.         if (optpat (lin, &i) == OK
  523.             && getrhs (lin, &i, sub, &gflag) == OK
  524.             && ckp (lin, i + 1, &pflag, status) == OK)
  525.         {
  526.             defalt (Curln, Curln);
  527.             *status = subst (sub, gflag, glob);
  528.         }
  529.         break;
  530.  
  531.     case TLITCOM:
  532.     case UCTLITCOM:
  533.         i++;
  534.         if (lin[i] == '\n')
  535.         {
  536.             /* turn "y\n" into "y//%/\n" */
  537.             lin[i+0] = '/';
  538.             lin[i+1] = '/';
  539.             lin[i+2] = '%';
  540.             lin[i+3] = '/';
  541.             lin[i+4] = '\n';
  542.             lin[i+5] = EOS;
  543.             Peekc = SKIP_RIGHT;
  544.         }
  545.         else
  546.         {
  547.             /* try to handle "y/stuff\n" */
  548.             int j, missing_delim;
  549.  
  550.             missing_delim = YES;
  551.             for (j = i + 1; lin[j] != '\n'; j++)
  552.                 if (lin[j] == ESCAPE && lin[j+1] == lin[i])
  553.                     j++;    /* skip esc, loop continues */
  554.                 else if (lin[j] == lin[i])
  555.                 {
  556.                     missing_delim = NO;
  557.                     break;    /* for */
  558.                 }
  559.  
  560.             if (missing_delim)
  561.             {
  562.                 for (; lin[j] != EOS; j++)
  563.                     ;
  564.                 j--;        /* j now at newline */
  565.  
  566.                 lin[j] = lin[i];    /* delim */
  567.                 lin[++j] = '\n';
  568.                 lin[++j] = EOS;
  569.                 Peekc = SKIP_RIGHT;
  570.                 /* rest of routines will continue to fix up */
  571.             }
  572.         }
  573.  
  574.         if (getrange (lin, &i, Tlpat, MAXPAT, &allbut) == OK
  575.             && makset (lin, &i, sub, MAXPAT) == OK
  576.             && ckp (lin, i + 1, &pflag, status) == OK)
  577.         {
  578.             defalt (Curln, Curln);
  579.             *status = dotlit (sub, allbut);
  580.         }
  581.         break;
  582.  
  583.     case JOINCOM:
  584.     case UCJOINCOM:
  585.         i++;
  586.         if (getstr (lin, &i, sub, MAXPAT) == OK
  587.             && ckp (lin, i + 1, &pflag, status) == OK)
  588.         {
  589.             defalt (prevln (Curln), Curln);
  590.             *status = join (sub);
  591.         }
  592.         break;
  593.  
  594.     case UNDOCOM:
  595.     case UCUNDOCOM:
  596.         i++;
  597.         defalt (Curln, Curln);
  598.         if (ckchar (UCDELCOM, DELCOM, lin, &i, &flag, status) == OK
  599.             && ckp (lin, i, &pflag, status) == OK)
  600.             *status = doundo (flag, status);
  601.         break;
  602.  
  603.     case ENTER:
  604.     case UCENTER:
  605.         i++;
  606.         if (Nlines != 0)
  607.             Errcode = EBADLNR;
  608.         else if (ckupd (lin, &i, ENTER, status) == OK
  609.             && ckchar ('x', 'X', lin, &i, &tflag, status) == OK)
  610.             if (getfn (lin, i - 1, file) == OK)
  611.             {
  612.                 strcpy (Savfil, expand_env (file));
  613.                 mesg (Savfil, FILE_MSG);
  614.                 clrbuf ();
  615.                 mkbuf ();
  616.                 dfltsopt (file);
  617.                 *status = doread (0, file, tflag);
  618.                 First_affected = 0;
  619.                 Curln = min (1, Lastln);
  620.                 Buffer_changed = NO;
  621.             }
  622.             else
  623.                 *status = ERR;
  624.         break;
  625.  
  626.     case PRINTFIL:
  627.     case UCPRINTFIL:
  628.         if (Nlines != 0)
  629.             Errcode = EBADLNR;
  630.         else if (getfn (lin, i, file) == OK)
  631.         {
  632.             strcpy (Savfil, expand_env (file));
  633.             mesg (Savfil, FILE_MSG);
  634.             *status = OK;
  635.         }
  636.         break;
  637.  
  638.     case READCOM:
  639.     case UCREADCOM:
  640.         i++;
  641.         if (ckchar ('x', 'X', lin, &i, &tflag, status) == OK)
  642.             if (getfn (lin, i - 1, file) == OK)
  643.             {
  644.                 defalt (Curln, Curln);
  645.                 *status = doread (Line2, file, tflag);
  646.             }
  647.         break;
  648.  
  649.     case WRITECOM:
  650.     case UCWRITECOM:
  651.         i++;
  652.         flag = NO;
  653.         fflag = NO;
  654.         junk = ckchar ('>', '+', lin, &i, &flag, &junk);
  655.         if (flag == NO)
  656.             junk = ckchar ('!', '!', lin, &i, &fflag, &junk);
  657.         junk = ckchar ('x', 'X', lin, &i, &tflag, &junk);
  658.         if (getfn (lin, i - 1, file) == OK)
  659.         {
  660.             defalt (1, Lastln);
  661.             *status = dowrit (Line1, Line2, file, flag, fflag, tflag);
  662.         }
  663.         break;
  664.  
  665.     case PRINT:
  666.     case UCPRINT:
  667.         if (lin[i + 1] == '\n')
  668.         {
  669.             defalt (1, Topln);
  670.             *status = doprnt (Line1, Line2);
  671.         }
  672.         break;
  673.  
  674.     case PAGECOM:
  675.         defalt (1, min (Lastln, Botrow - Toprow + Topln));
  676.         if (Line1 <= 0)
  677.             Errcode = EORANGE;
  678.         else if (lin[i + 1] == '\n')
  679.         {
  680.             Topln = Line2;
  681.             Curln = Line2;
  682.             First_affected = Line2;
  683.             *status = OK;
  684.         }
  685.         break;
  686.  
  687.     case NAMECOM:
  688.     case UCNAMECOM:
  689.         i++;
  690.         if (getkn (lin, &i, &kname, DEFAULTNAME) != ERR
  691.             && lin[i] == '\n')
  692.             uniquely_name (kname, status);
  693.         break;
  694.  
  695.     case MARKCOM:
  696.     case UCMARKCOM:
  697.         i++;
  698.         if (getkn (lin, &i, &kname, DEFAULTNAME) != ERR
  699.             && lin[i] == '\n')
  700.         {
  701.             defalt (Curln, Curln);
  702.             *status = domark (kname);
  703.         }
  704.         break;
  705.  
  706.     case '\n':
  707.         line3 = nextln (Curln);
  708.         defalt (line3, line3);
  709.         *status = doprnt (Line2, Line2);
  710.         break;
  711.  
  712.     case LOCATECMD:
  713.     case UCLOCATECMD:
  714.         if (lin[i+1] == '\n')
  715.         {
  716.             char *sysname ();
  717.  
  718.             remark (sysname ());
  719.             *status = OK;
  720.         }
  721.         break;
  722.  
  723.     case OPTCOM:
  724.     case UCOPTCOM:
  725.         if (Nlines == 0)
  726.             *status = doopt (lin, &i);
  727.         else
  728.             Errcode = EBADLNR;
  729.         break;
  730.  
  731.     case QUIT:
  732.     case UCQUIT:
  733.         i++;
  734.         if (Nlines != 0)
  735.             Errcode = EBADLNR;
  736.         else if (ckupd (lin, &i, QUIT, status) == OK)
  737.             if (lin[i] == '\n')
  738.                 *status = EOF;
  739.             else
  740.                 *status = ERR;
  741.         break;
  742.  
  743.     case HELP:
  744.     case UCHELP:
  745.         i++;
  746.         if (Nlines == 0)
  747.             dohelp (lin, &i, status);
  748.         else
  749.             Errcode = EBADLNR;
  750.         break;
  751.  
  752.     case MISCCOM:        /* miscellanious features */
  753.     case UCMISCCOM:
  754.         i++;
  755.         switch (lin[i]) {
  756.         case 'b':    /* draw box */
  757.         case 'B':
  758.             defalt (Curln, Curln);
  759.             i++;
  760.             *status = draw_box (lin, &i);
  761.             break;
  762.  
  763.         default:
  764.             Errcode = EWHATZAT;
  765.             break;
  766.         }
  767.         break;
  768.  
  769.     case SHELLCOM:
  770.         i++;
  771.         defalt (Curln, Curln);
  772.         *status = doshell (lin, &i);
  773.         break;
  774.  
  775.     default:
  776.         Errcode = EWHATZAT;    /* command not recognized */
  777.         break;
  778.     }
  779.  
  780.     if (*status == OK)
  781.         Probation = NO;
  782.  
  783.     return (*status);
  784. }
  785.  
  786.  
  787. /* dohelp --- display documentation about editor */
  788.  
  789. dohelp (lin, i, status)
  790. char lin[];
  791. int *i, *status;
  792. {
  793.     char filename[MAXLINE];
  794.     char swt_filename[MAXLINE];
  795.     static char helpdir[] = "/usr/local/lib/se_h";    /* help scripts */
  796.     int j;
  797.     FILE *fp, *fopen ();
  798.  
  799.     SKIPBL (lin, *i);
  800.     if (lin[*i] == NEWLINE)
  801.         sprintf (filename, "%s/elp", helpdir);
  802.     else
  803.     {
  804.         /* build filename from text after "h" */
  805.         sprintf (filename, "%s/%s", helpdir, &lin[*i]);
  806.         j = strlen (filename);
  807.         filename[j-1] = EOS;    /* lop off newline */
  808.     }
  809.  
  810.     /* map to lower case */
  811.     for (j = 0; filename[j] != EOS; j++)
  812.         if (isupper (filename[j]))
  813.             filename[j] = tolower (filename[j]);
  814.  
  815.     *status = OK;
  816.     if ((fp = fopen (filename, "r")) == NULL)
  817.     {
  818.         *status = ERR;
  819.         Errcode = ENOHELP;
  820.     }
  821.     else
  822.     {
  823. #ifdef u3b2
  824.         /* 3B2 seems to have problems with stdio and malloc... */
  825.         char buf[BUFSIZ];
  826.         setbuf (fp, buf);
  827. #endif
  828.  
  829.         /* status is OK */
  830.         display_message (fp);    /* display the help script */
  831.         fclose (fp);
  832.     }
  833. }
  834.  
  835.  
  836. /* doopt --- interpret option command */
  837.  
  838. int doopt (lin, i)
  839. char lin[];
  840. int *i;
  841. {
  842.     int temp, line, stat;
  843.     char tempstr[4];
  844.     int ret;
  845.     int dosopt ();
  846.     int ctoi ();
  847.  
  848.     (*i)++;
  849.     ret = ERR;
  850.  
  851.     switch (lin[*i]) {
  852.  
  853.     case 'g':        /* substitutes in a global can(not) fail */
  854.     case 'G':
  855.         if (lin[*i + 1] == '\n')
  856.         {
  857.             ret = OK;
  858.             Globals = ! Globals;    /* toggle */
  859.             if (Globals == YES)
  860.                 remark ("failed global substitutes continue");
  861.             else
  862.                 remark ("failed global substitutes stop");
  863.         }
  864.         break;
  865.  
  866.     case 'h':
  867.     case 'H':        /* do/don't use hardware insert/delete */
  868.         if (lin[*i + 1] == '\n')
  869.         {
  870.             ret = OK;
  871.             No_hardware = ! No_hardware;
  872.             if (No_hardware == YES)
  873.                 remark ("no line insert/delete");
  874.             else
  875.                 remark ("line insert/delete");
  876.         }
  877.         break;
  878.  
  879.     case 'k':        /* tell user if buffer saved or not */
  880.     case 'K':
  881.         if (lin[*i + 1] == '\n')
  882.         {
  883.             ret = OK;
  884.             if (Buffer_changed == YES)
  885.                 remark ("not saved");
  886.             else
  887.                 remark ("saved");
  888.         }
  889.         break;
  890.  
  891.  
  892.     case 'z':    /* suspend the editor process */
  893.     case 'Z':
  894.         if (lin[*i + 1] == '\n')
  895.         {
  896.             ret = OK;
  897. #ifdef BSD
  898.             if (Catching_stops)
  899.             {
  900.                 if (Buffer_changed == YES)
  901.                     fprintf (stderr, "WARNING: buffer not saved\r\n");
  902.                 kill (getpid(), SIGTSTP);
  903.                 /* stop_hdlr() will do all the work for us */
  904.             }
  905. #else
  906.             remark ("process suspension not available");
  907. #endif
  908.         }
  909.         break;
  910.  
  911.     case 't':    /* set or display tab stops for expanding tabs */
  912.     case 'T':
  913.         ++(*i);
  914.         if (lin[*i] == '\n')
  915.         {
  916.             remark (Tabstr);
  917.             ret = OK;
  918.         }
  919.         else
  920.         {
  921.             ret = settab (&lin[*i]);
  922.             if (ret == OK)
  923.                 strcpy (Tabstr, &lin[*i]);
  924.             else    /* defaults were set */
  925.                 strcpy (Tabstr, "+4");
  926.         }
  927.         break;
  928.  
  929.     case 'w':    /* set or display warning column */
  930.     case 'W':
  931.         ++(*i);
  932.         if (lin[*i] == '\n')
  933.             ret = OK;
  934.         else
  935.         {
  936.             temp = ctoi (lin, i);
  937.             if (lin[*i] == '\n')
  938.                 if (temp > 0 && temp < MAXLINE - 3)
  939.                 {
  940.                     ret = OK;
  941.                     Warncol = temp;
  942.                 }
  943.                 else
  944.                     Errcode = ENONSENSE;
  945.         }
  946.         if (ret == OK)
  947.             saynum (Warncol);
  948.         break;
  949.  
  950.     case '-':    /* fix window in place on screen, or erase it */
  951.         ++(*i);
  952.         if (getnum (lin, i, &line, &stat) == EOF)
  953.         {
  954.             mesg ("", HELP_MSG);
  955.             if (Toprow > 0)
  956.             {
  957.                 Topln = max (1, Topln - Toprow);
  958.                 Toprow = 0;
  959.                 First_affected = Topln;
  960.             }
  961.             ret = OK;
  962.         }
  963.         else if (stat != ERR && lin[*i] == '\n')
  964.             if (Toprow + (line - Topln + 1) < Cmdrow)
  965.             {
  966.                 Toprow += line - Topln + 1;
  967.                 Topln = line + 1;
  968.                 for (temp = 0; temp < Ncols; temp++)
  969.                     load ('-', Toprow - 1, temp);
  970.                 if (Topln > Lastln)
  971.                     adjust_window (1, Lastln);
  972.                 if (Curln < Topln)
  973.                     Curln = min (Topln, Lastln);
  974.                 ret = OK;
  975.             }
  976.             else
  977.                 Errcode = EORANGE;
  978.         break;
  979.  
  980.     case 'a':    /* toggle absolute line numbering */
  981.     case 'A':
  982.         if (lin[*i + 1] == '\n')
  983.         {
  984.             Absnos = ! Absnos;
  985.             ret = OK;
  986.         }
  987.         break;
  988.  
  989.     case 'c':    /* toggle case option */
  990.     case 'C':
  991.         if (lin[*i + 1] == '\n')
  992.         {
  993.             ret = OK;
  994.             Invert_case = ! Invert_case;
  995.             if (Rel_a == 'A')
  996.             {
  997.                 Rel_a = 'a';
  998.                 Rel_z = 'z';
  999.             }
  1000.             else
  1001.             {
  1002.                 Rel_a = 'A';
  1003.                 Rel_z = 'Z';
  1004.             }
  1005.         }
  1006.  
  1007.         mesg (Invert_case ? "CASE" : "", CASE_MSG);
  1008.         break;
  1009.  
  1010.     case 'd':    /* set or display placement of "." after a delete */
  1011.     case 'D':
  1012.         if (lin[*i + 1] == '\n')
  1013.         {
  1014.             if (Ddir == FORWARD)
  1015.                 remark (">");
  1016.             else
  1017.                 remark ("<");
  1018.             ret = OK;
  1019.         }
  1020.         else if (lin[*i + 2] != '\n')
  1021.             Errcode = EODLSSGTR;
  1022.         else if (lin[*i + 1] == '>')
  1023.         {
  1024.             ret = OK;
  1025.             Ddir = FORWARD;
  1026.         }
  1027.         else if (lin[*i + 1] == '<')
  1028.         {
  1029.             ret = OK;
  1030.             Ddir = BACKWARD;
  1031.         }
  1032.         else
  1033.             Errcode = EODLSSGTR;
  1034.         break;
  1035.  
  1036.     case 'v':    /* set or display overlay column */
  1037.     case 'V':
  1038.         ++(*i);
  1039.         if (lin[*i] == '\n')
  1040.         {
  1041.             if (Overlay_col == 0)
  1042.                 remark ("$");
  1043.             else
  1044.                 saynum (Overlay_col);
  1045.             ret = OK;
  1046.         }
  1047.         else
  1048.         {
  1049.             if (lin[*i] == '$' && lin[*i + 1] == '\n')
  1050.             {
  1051.                 Overlay_col = 0;
  1052.                 ret = OK;
  1053.             }
  1054.             else
  1055.             {
  1056.                 temp = ctoi (lin, i);
  1057.                 if (lin[*i] == '\n')
  1058.                 {
  1059.                     Overlay_col = temp;
  1060.                     ret = OK;
  1061.                 }
  1062.                 else
  1063.                     Errcode = ENONSENSE;
  1064.             }
  1065.         }
  1066.         break;
  1067.  
  1068.     case 'u':    /* set or display character for unprintable chars */
  1069.     case 'U':
  1070.         if (lin[*i + 1] == '\n')
  1071.         {
  1072.             ret = OK;
  1073.             tempstr[0] = tempstr[2] = '"';
  1074.             tempstr[1] = Unprintable;
  1075.             tempstr[3] = EOS;
  1076.             remark (tempstr);
  1077.         }
  1078.         else if (lin[*i + 2] == '\n')
  1079.         {
  1080.             if (lin[*i + 1] < ' ' || lin[*i + 1] >= DEL)
  1081.                 Errcode = ENONSENSE;
  1082.             else 
  1083.             {
  1084.                 ret = OK;
  1085.                 if (Unprintable != lin[*i + 1])
  1086.                 {
  1087.                     Unprintable = lin[*i + 1];
  1088.                     First_affected = Topln;
  1089.                 }
  1090.             }
  1091.         }
  1092.         break;
  1093.  
  1094.     case 'l':    /* set or display line number display option */
  1095.     case 'L':
  1096.         if (lin[*i+1] == '\n')
  1097.         {
  1098.             Nchoise = EOS;
  1099.             ret = OK;
  1100.         }
  1101.         else if (lin[*i + 2] == '\n' && 
  1102.             (lin[*i + 1] == CURLINE || lin[*i + 1] == LASTLINE
  1103.             || lin[*i + 1] == TOPLINE))
  1104.         {
  1105.             Nchoise = lin[*i + 1];
  1106.             ret = OK;
  1107.         }
  1108.         else if (lin[*i + 1] == 'm' || lin[*i + 1] == 'M')
  1109.         {
  1110.             /* set or display the left margin */
  1111.             (*i)++;
  1112.             if (lin[*i + 1] == '\n')
  1113.             {
  1114.                 saynum (Firstcol + 1);
  1115.                 ret = OK;
  1116.             }
  1117.             else 
  1118.             {
  1119.                 (*i)++;
  1120.                 temp = ctoi (lin, i);
  1121.                 if (lin[*i] == '\n')
  1122.                     if (temp > 0 && temp < MAXLINE)
  1123.                     {
  1124.                         First_affected = Topln;
  1125.                         Firstcol = temp - 1;
  1126.                         ret = OK;
  1127.                     }
  1128.                     else
  1129.                         Errcode = ENONSENSE;
  1130.             }
  1131.         }
  1132.         break;
  1133.  
  1134.     case 'f':    /* fortran (ugh, yick, gross) options */
  1135.     case 'F':
  1136.         if (lin[*i + 1] == '\n')
  1137.             ret = dosopt ("f");
  1138.         break;
  1139.  
  1140.     case 's':    /* set source options */
  1141.     case 'S':
  1142.         ret = dosopt (&lin[*i + 1]);
  1143.         break;
  1144.  
  1145.     case 'i':    /* set or display indent option */
  1146.     case 'I':
  1147.         ++(*i);
  1148.         if (lin[*i] == '\n')
  1149.             ret = OK;
  1150.         else if ((lin[*i] == 'a' || lin[*i] == 'A') && lin[*i + 1] == '\n')
  1151.         {
  1152.             Indent = 0;
  1153.             ret = OK;
  1154.         }
  1155.         else
  1156.         {
  1157.             temp = ctoi (lin, i);
  1158.             if (lin[*i] == '\n')
  1159.                 if (temp > 0 && temp < MAXLINE - 3)
  1160.                 {
  1161.                     ret = OK;
  1162.                     Indent = temp;
  1163.                 }
  1164.                 else
  1165.                     Errcode = ENONSENSE;
  1166.         }
  1167.         if (ret == OK)
  1168.             if (Indent > 0)
  1169.                 saynum (Indent);
  1170.             else
  1171.                 remark ("auto");
  1172.         break;
  1173.  
  1174.     case 'm':    /* toggle mail notification */
  1175.     case 'M':
  1176.         if (lin[*i + 1] == '\n')
  1177.         {
  1178.             Notify = ! Notify;    /* toggle notification */
  1179.             remark (Notify ? "notify on" : "notify off");
  1180.             ret = OK;
  1181.         }
  1182.         break;
  1183.  
  1184.     case 'x':
  1185.     case 'X':    /* toggle tab compression */
  1186.         if (lin[*i + 1] == '\n')
  1187.         {
  1188.             ret = OK;
  1189.             Compress = ! Compress;
  1190.             mesg (Compress ? "XTABS" : "", COMPRESS_MSG);
  1191.         }
  1192.         break;
  1193.  
  1194.     case 'y':    /* encrypt files */
  1195.     case 'Y':
  1196.         if (lin[*i + 1] == '\n')
  1197.         {
  1198.         crypt_toggle:
  1199.             ret = OK;
  1200.             Crypting = ! Crypting;
  1201.             if (Crypting )
  1202.                 do {
  1203.                     getkey ();
  1204.                     if (Key[0] == EOS)
  1205.                         remark ("Empty keys are not allowed.\n");
  1206.                 } while (Key[0] == EOS);
  1207.             else
  1208.                 Key[0] = EOS;
  1209.         }
  1210.         else
  1211.         {
  1212.             register int j;
  1213.  
  1214.             ret = OK;
  1215.             (*i)++;        /* *i was the 'y' */
  1216.             while (isspace (lin[*i]) && lin[*i] != '\n')
  1217.                 (*i)++;
  1218.             if (lin[*i] != '\n' && lin[*i] != EOS)
  1219.             {
  1220.                 for (j = 0; lin[*i] != '\n' && lin[*i] != EOS;
  1221.                     j++, (*i)++)
  1222.                     Key[j] = lin[*i];
  1223.                 Key[j] = EOS;
  1224.                 Crypting = YES;
  1225.             }
  1226.             else
  1227.                 goto crypt_toggle;
  1228.         }
  1229.         mesg (Crypting ? "ENCRYPT" : "", CRYPT_MSG);
  1230.         break;
  1231.  
  1232.     default:
  1233.         Errcode = EOWHAT;
  1234.  
  1235.     }
  1236.  
  1237.     return (ret);
  1238. }
  1239.  
  1240.  
  1241. /* domark --- name lines line1 through line2 as kname */
  1242.  
  1243. int domark (kname)
  1244. char kname;
  1245. {
  1246.     int line;
  1247.     int ret;
  1248.     register LINEDESC *k;
  1249.     LINEDESC *getind ();
  1250.  
  1251.     if (Line1 <= 0)
  1252.     {
  1253.         Errcode = EORANGE;
  1254.         ret = ERR;
  1255.     }
  1256.     else
  1257.     {
  1258.         k = getind (Line1);
  1259.         for (line = Line1; line <= Line2; line++)
  1260.         {
  1261.             if (intrpt())
  1262.                 return (ERR);
  1263.             k -> Markname = kname;
  1264.             k = NEXTLINE(k);
  1265.         }
  1266.         ret = OK;
  1267.     }
  1268.     return (ret);
  1269. }
  1270.  
  1271.  
  1272. /* doprnt --- set curln, locate window */
  1273.  
  1274. int doprnt (from, to)
  1275. int from, to;
  1276. {
  1277.  
  1278.     if (from <= 0)
  1279.     {
  1280.         Errcode = EORANGE;
  1281.         return (ERR);
  1282.     }
  1283.  
  1284.     adjust_window (from, to);
  1285.     Curln = to;
  1286.     return (OK);
  1287. }
  1288.  
  1289.  
  1290. /* doread --- read "file" after "line" */
  1291.  
  1292. int doread (line, file, tflag)
  1293. int line;
  1294. char *file;
  1295. int tflag;
  1296. {
  1297.     register int count, len, i;
  1298.     int ret;
  1299.     int strlen ();
  1300.     FILE *fd;
  1301.     FILE *fopen (), *crypt_open ();
  1302.     char lin1[MAXLINE], lin2[MAXLINE];
  1303.     char *fgets ();
  1304.     register LINEDESC *ptr;
  1305.     LINEDESC *sp_inject ();
  1306.     LINEDESC *getind ();
  1307.     char *expand_env ();
  1308.  
  1309.     file = expand_env (file);    /* expand $HOME, etc. */
  1310.  
  1311.     if (Savfil[0] == EOS)
  1312.     {
  1313.         strcpy (Savfil, file);
  1314.         mesg (Savfil, FILE_MSG);
  1315.     }
  1316.  
  1317.     if (Crypting)
  1318.         fd = crypt_open (file, "r");
  1319.     else
  1320.         fd = fopen (file, "r");
  1321.  
  1322.     if (fd == NULL)
  1323.     {
  1324.         ret = ERR;
  1325.         Errcode = ECANTREAD;
  1326.     }
  1327.     else
  1328.     {
  1329.         First_affected = min (First_affected, line + 1);
  1330.         ptr = getind (line);
  1331.         ret = OK;
  1332. #ifndef OLD_SCRATCH
  1333.         Curln = line;
  1334. #endif
  1335.         remark ("reading");
  1336.         for (count = 0; fgets (lin1, MAXLINE, fd) != NULL; count++)
  1337.         {
  1338.             if (intrpt ())
  1339.             {
  1340.                 ret = ERR;
  1341.                 break;
  1342.             }
  1343.             if (Compress == NO && tflag == NO)
  1344.                 ptr = sp_inject (lin1, strlen (lin1), ptr);
  1345.             else
  1346.             {
  1347.                 len = 0;
  1348.                 for (i = 0; lin1[i] != EOS && len < MAXLINE - 1; i++)
  1349.                     if (lin1[i] != '\t')
  1350.                         lin2[len++] = lin1[i];
  1351.                     else
  1352.                         do
  1353.                             lin2[len++] = ' ';
  1354.                         while (len % 8 != 0 
  1355.                             && len < MAXLINE - 1);
  1356.                 lin2[len] = EOS;
  1357.                 if (len >= MAXLINE)
  1358.                 {
  1359.                     ret = ERR;
  1360.                     Errcode = ETRUNC;
  1361.                 }
  1362.                 ptr = sp_inject (lin2, len, ptr);
  1363.             }
  1364.             if (ptr == NOMORE)
  1365.             {
  1366.                 ret = ERR;
  1367.                 break;
  1368.             }
  1369.         }
  1370.         if (Crypting)
  1371.             crypt_close (fd);
  1372.         else
  1373.             fclose (fd);
  1374.         saynum (count);
  1375.         Curln = line + count;
  1376.         svins (line, count);
  1377.     }
  1378.  
  1379.     return (ret);
  1380. }
  1381.  
  1382.  
  1383. /* dosopt --- set source language-related options */
  1384.  
  1385. int dosopt (lin)
  1386. char lin[];
  1387. {
  1388.     char lang[8];
  1389.     int i;
  1390.     int strbsr ();
  1391.     static struct {
  1392.         char *txt;
  1393.         int val;
  1394.     } ltxt[] = {    
  1395.         "",     1,
  1396.         "as",   2,
  1397.         "c",    3,
  1398.         "d",    1,
  1399.         "data", 1,
  1400.         "f",    4,
  1401.         "h",    3,
  1402.         "n",    1,
  1403.         "nr",   1,
  1404.         "nroff",1,
  1405.         "p",    3,
  1406.         "r",    3,
  1407.         "s",    2,
  1408.     };
  1409.  
  1410.     i = 0;
  1411.     getwrd (lin, &i, lang, 8);
  1412.  
  1413.     strmap (lang, 'a');
  1414.  
  1415.     i = strbsr ((char *)ltxt, sizeof (ltxt), sizeof (ltxt[0]), lang);
  1416.     if (i == EOF)
  1417.     {
  1418.         Errcode = ENOLANG;
  1419.         return (ERR);
  1420.     }
  1421.  
  1422.     /*
  1423.      * these are all the same under Unix, so factor
  1424.      * them out of the switch.
  1425.      */
  1426.  
  1427.     Rel_a = 'A';
  1428.     Rel_z = 'Z';
  1429.     Invert_case = NO;
  1430.     Compress = NO;
  1431.  
  1432.     switch (ltxt[i].val) {
  1433.     case 1:
  1434.         Warncol = 74;
  1435.         strcpy (Tabstr, "+4");
  1436.         break;
  1437.  
  1438.     case 2:
  1439.         Warncol = 72;
  1440.         strcpy (Tabstr, "17+8");
  1441.         Compress = YES;        /* except this one */
  1442.         break;
  1443.  
  1444.     case 3:
  1445.         Warncol = 74;
  1446.         strcpy (Tabstr, "+8");
  1447.         break;
  1448.  
  1449.     case 4:
  1450.         Warncol = 72;
  1451.         strcpy (Tabstr, "7+3");
  1452.         break;
  1453.     }
  1454.  
  1455.     settab (Tabstr);
  1456.     mesg (Invert_case == YES ? "CASE" : "", CASE_MSG);
  1457.     mesg (Compress == YES ? "XTABS" : "", COMPRESS_MSG);
  1458.  
  1459.     return (OK);
  1460. }
  1461.  
  1462.  
  1463. /* dotlit --- transliterate characters */
  1464.  
  1465. int dotlit (sub, allbut)
  1466. char sub[];
  1467. int allbut;
  1468. {
  1469.     char new[MAXLINE];
  1470.     char kname;
  1471.     int collap, x, i, j, line, lastsub, status;
  1472.     int ret;
  1473.     LINEDESC *inx;
  1474.     LINEDESC *gettxt (), *getind ();
  1475.  
  1476.     ret = ERR;
  1477.     if (Line1 <= 0)
  1478.     {
  1479.         Errcode = EORANGE;
  1480.         return (ret);
  1481.     }
  1482.  
  1483.     if (First_affected > Line1)
  1484.         First_affected = Line1;
  1485.  
  1486.     lastsub = strlen (sub) - 1;
  1487.     if ((strlen (Tlpat)  - 1) > lastsub || allbut == YES)
  1488.         collap = YES;
  1489.     else
  1490.         collap = NO;
  1491.  
  1492.     for (line = Line1; line <= Line2; line++)
  1493.     {
  1494.         if (intrpt ())    /* check for interrupts */
  1495.             return (ERR);
  1496.  
  1497.         inx = gettxt (line);    /* get text of line into txt, return index */
  1498.         j = 0;
  1499.         for (i = 0; Txt[i] != EOS && Txt[i] != '\n'; i++)
  1500.         {
  1501.             x = xindex (Tlpat, Txt[i], allbut, lastsub);
  1502.             if (collap == YES && x >= lastsub && lastsub >= 0)    /* collapse */
  1503.             {
  1504.                 new[j] = sub[lastsub];
  1505.                 j++;
  1506.                 for (i++; Txt[i] != EOS && Txt[i] != '\n'; i++)
  1507.                 {
  1508.                     x = xindex (Tlpat, Txt[i], allbut, lastsub);
  1509.                     if (x < lastsub)
  1510.                         break;
  1511.                 }
  1512.             }
  1513.             if (Txt[i] == EOS || Txt[i] == '\n')
  1514.                 break;
  1515.             if (x >= 0 && lastsub >= 0)    /* transliterate */
  1516.             {
  1517.                 new[j] = sub[x];
  1518.                 j++;
  1519.             }
  1520.             else if (x < 0)        /* copy */
  1521.             {
  1522.                 new[j] = Txt[i];
  1523.                 j++;
  1524.             }
  1525.             /* else
  1526.                 delete */
  1527.         }
  1528.  
  1529.         if (Txt[i] == '\n')    /* add a newline, if necessary */
  1530.         {
  1531.             new[j] = '\n';
  1532.             j++;
  1533.         }
  1534.         new[j] = EOS;        /* add the EOS */
  1535.  
  1536.         kname = inx -> Markname;    /* save the markname */
  1537.         delete (line, line, &status);
  1538.         ret = inject (new);
  1539.         if (ret == ERR)
  1540.             break;
  1541.         inx = getind (Curln);
  1542.         inx -> Markname = kname;    /* set markname */
  1543.         ret = OK;
  1544.         Buffer_changed = YES;
  1545.     }
  1546.  
  1547.     return (ret);
  1548. }
  1549.  
  1550. /* doundo --- restore last set of lines deleted */
  1551.  
  1552. int doundo (dflg, status)
  1553. int dflg;
  1554. int *status;
  1555. {
  1556.     LINEDESC *l1, *l2, *k1, *k2;
  1557.     LINEDESC *getind ();
  1558.     int oldcnt;
  1559.     int nextln (), prevln ();
  1560.  
  1561.     *status = ERR;
  1562.     if (dflg == NO && Line1 <= 0)
  1563.         Errcode = EORANGE;
  1564.     else if (Limbo == NOMORE)
  1565.         Errcode = ENOLIMBO;
  1566.     else if (Line1 > Line2)
  1567.         Errcode = EBACKWARD;
  1568.     else if (Line2 > Lastln)
  1569.         Errcode = ELINE2;
  1570.     else
  1571.     {
  1572.         *status = OK;
  1573.         Curln = Line2;
  1574. #ifdef OLD_SCRATCH
  1575.         k1 = getind (Line2);
  1576.         k2 = getind (nextln (Line2));
  1577.         l1 = Limbo;
  1578.         l2 = l1 -> Prevline;
  1579.         relink (k1, l1, l2, k2);
  1580.         relink (l2, k2, k1, l1);
  1581. #else
  1582.         blkmove (Limbo - Buf, MAXBUF - 1, Line2);
  1583. #endif
  1584.         svins (Line2, Limcnt);
  1585.         oldcnt = Limcnt;
  1586.         Limcnt = 0;
  1587.         Limbo = NOMORE;
  1588.         Lastln += oldcnt;
  1589.         if (dflg == NO)
  1590.             delete (Line1, Line2, status);
  1591.         Curln += oldcnt;
  1592.         if (First_affected > Line1)
  1593.             First_affected = Line1;
  1594.     }
  1595.  
  1596.     return (*status);
  1597. }
  1598.  
  1599. /* dowrit --- write "from" through "to" into file */
  1600.  
  1601. int dowrit (from, to, file, aflag, fflag, tflag)
  1602. int from, to, aflag, fflag, tflag;
  1603. char *file;
  1604. {
  1605.     FILE *fd;
  1606.     FILE *fopen (), *crypt_open ();
  1607.     register int line, ret, i, j;
  1608.     int strcmp (), access ();
  1609.     char tabs[MAXLINE];
  1610.     register LINEDESC *k;
  1611.     LINEDESC *getind ();
  1612.     char *expand_env ();
  1613.  
  1614.     ret = ERR;
  1615.     if (from <= 0)
  1616.         Errcode = EORANGE;
  1617.  
  1618.     else
  1619.     {
  1620.         file = expand_env (file);    /* expand $HOME, etc. */
  1621.  
  1622.         if (aflag == YES)
  1623.         {
  1624.             if (Crypting)
  1625.                 fd = crypt_open (file, "a");
  1626.             else
  1627.                 fd = fopen (file, "a");
  1628.         }
  1629.         else if (strcmp (file, Savfil) == 0 || fflag == YES
  1630.             || Probation == WRITECOM || access (file, 0) == -1)
  1631.         {
  1632.             if (Crypting)
  1633.                 fd = crypt_open (file, "w");
  1634.             else
  1635.                 fd = fopen (file, "w");
  1636.         }
  1637.         else
  1638.         {
  1639.             Errcode = EFEXISTS;
  1640.             Probation = WRITECOM;
  1641.             return (ret);
  1642.         }
  1643.         if (fd == NULL)
  1644.             Errcode = ECANTWRITE;
  1645.         else
  1646.         {
  1647.             ret = OK;
  1648.             remark ("writing");
  1649.             k = getind (from);
  1650.             for (line = from; line <= to; line++)
  1651.             {
  1652.                 if (intrpt ())
  1653.                     return (ERR);
  1654.                 gtxt (k);
  1655.                 if (Compress == NO && tflag == NO)
  1656.                     fputs (Txt, fd);
  1657.                 else
  1658.                 {
  1659.                     for (i = 0; Txt[i] == ' '; i++)
  1660.                         ;
  1661.                     for (j = 0; j < i / 8; j++)
  1662.                         tabs[j] = '\t';
  1663.                     tabs[j] = EOS;
  1664.                     fputs (tabs, fd);
  1665.                     fputs (&Txt[j * 8], fd);
  1666.                 }
  1667.                 k = NEXTLINE(k);
  1668.             }
  1669.             if (Crypting)
  1670.                 crypt_close (fd);
  1671.             else
  1672.                 fclose (fd);
  1673.             sync ();    /* just in case the system crashes */
  1674.             saynum (line - from);
  1675.             if (from == 1 && line - 1 == Lastln)
  1676.                 Buffer_changed = NO;
  1677.         }
  1678.     }
  1679.     return (ret);
  1680. }
  1681.  
  1682. /* expand_env --- expand environment variables in file names */
  1683.  
  1684. char *expand_env (file)
  1685. register char *file;
  1686. {
  1687.     register int i, j, k;        /* indices */
  1688.     char *getenv ();
  1689.     char var[MAXLINE];        /* variable name */
  1690.     char *val;            /* value of environment variable */
  1691.     static char buf[MAXLINE * 2];    /* expanded file name, static to not go away */
  1692.  
  1693.  
  1694.     i = j = k = 0;
  1695.     while (file[i] != EOS)
  1696.     {
  1697.         if (file[i] == ESCAPE)
  1698.         {
  1699.             if (file[i+1] == '$')
  1700.             {
  1701.                 buf[j++] = file[++i];    /* the actual $ */
  1702.                 i++;    /* for next time around the loop */
  1703.             }
  1704.             else
  1705.                 buf[j++] = file[i++];    /* the \ */
  1706.         }
  1707.         else if (file[i] != '$')    /* normal char */
  1708.             buf[j++] = file[i++];
  1709.         else            /* environment var */
  1710.         {
  1711.             i++;    /* skip $ */
  1712.             k = 0;
  1713.             while (file[i] != '/' && file[i] != EOS)
  1714.                 var[k++] = file[i++];    /* get var name */
  1715.             var[k] = EOS;
  1716.  
  1717.             if ((val = getenv (var)) != NULL)
  1718.                 for (k = 0; val[k] != EOS; k++)
  1719.                     buf[j++] = val[k];
  1720.                     /* copy val into file name */
  1721.             else if (file[i] == '/')
  1722.                 i++;    /* var not in enviroment; strip */
  1723.                     /* extra slash */
  1724.         }
  1725.     }
  1726.     buf[j] = EOS;
  1727.  
  1728.     return (buf);
  1729. }
  1730.  
  1731. /* crypt_open -- run files through crypt */
  1732.  
  1733. FILE *crypt_open (file, mode)
  1734. char *file, *mode;
  1735. {
  1736.     char buf[MAXLINE];
  1737.     FILE *fp, *popen ();
  1738.  
  1739.     if (! Crypting)
  1740.         return (NULL);
  1741.  
  1742.     while (Key[0] == EOS)
  1743.     {
  1744.         getkey ();
  1745.         if (Key[0] == EOS)
  1746.             fprintf (stderr, "The key must be non-empty!\r\n");
  1747.     }
  1748.  
  1749.     switch (mode[0]) {
  1750.     case 'r':
  1751.         sprintf (buf, "crypt %s < %s", Key, file);
  1752.         fp = popen (buf, "r");
  1753.         return (fp);        /* caller checks for NULL or not */
  1754.         break;
  1755.  
  1756.     case 'w':
  1757.         sprintf (buf, "crypt %s > %s", Key, file);
  1758.         fp = popen (buf, "w");
  1759.         return (fp);        /* caller checks for NULL or not */
  1760.         break;
  1761.  
  1762.     case 'a':
  1763.         sprintf (buf, "crypt %s >> %s", Key, file);
  1764.         fp = popen (buf, "w");
  1765.         return (fp);        /* caller checks for NULL or not */
  1766.         break;
  1767.     
  1768.     default:
  1769.         return (NULL);
  1770.     }
  1771. }
  1772.  
  1773. crypt_close (fp)
  1774. FILE *fp;
  1775. {
  1776.     pclose (fp);
  1777. }
  1778.  
  1779. /* getkey -- get an encryption key from the user */
  1780.  
  1781. #define repeat        do
  1782. #define until(cond)    while(!(cond))
  1783.  
  1784. getkey ()
  1785. {
  1786.     char *getpass ();    /* get input w/out echoing on screen */
  1787.  
  1788.     clrscreen ();        /* does NOT wipe out Screen_image */
  1789.     tflush ();
  1790.  
  1791.     ttynormal ();
  1792.  
  1793.     repeat
  1794.     {
  1795.         strcpy (Key, getpass ("Enter encryption key: "));
  1796.         if (strcmp (Key, getpass ("Again: ")) != 0)
  1797.         {
  1798.             Key[0] = EOS;
  1799.             fprintf (stderr, "didn't work. try again.\n");
  1800.         }
  1801.         /* else
  1802.             all ok */
  1803.     } until (Key[0] != EOS);
  1804.  
  1805.     ttyedit ();
  1806.  
  1807.     restore_screen ();
  1808. }
  1809. SHAR_EOF
  1810. fi # end of overwriting check
  1811. echo shar: extracting "'docmd2.c'" '(18109 characters)'
  1812. if test -f 'docmd2.c'
  1813. then
  1814.     echo shar: will not over-write existing file "'docmd2.c'"
  1815. else
  1816. cat << \SHAR_EOF > 'docmd2.c'
  1817. #ifndef lint
  1818. static char RCSid[] = "$Header: docmd2.c,v 1.3 86/07/17 17:20:29 arnold Exp $";
  1819. #endif
  1820.  
  1821. /*
  1822.  * $Log:    docmd2.c,v $
  1823.  * Revision 1.3  86/07/17  17:20:29  arnold
  1824.  * Some general code cleaning up.
  1825.  * 
  1826.  * Revision 1.2  86/07/11  15:11:04  osadr
  1827.  * Removed Georgia Tech specific code.
  1828.  * 
  1829.  * Revision 1.1  86/05/06  13:36:57  osadr
  1830.  * Initial revision
  1831.  * 
  1832.  * 
  1833.  */
  1834.  
  1835. /*
  1836. ** docmd2.c
  1837. **
  1838. ** routines to actually execute commands
  1839. */
  1840.  
  1841. #include "se.h"
  1842. #include "extern.h"
  1843.  
  1844.  
  1845. /* append --- append lines after "line" */
  1846.  
  1847. append (line, str)
  1848. int line;
  1849. char str[];
  1850. {
  1851.     char lin[MAXLINE];
  1852.     char term;
  1853.     int ret;
  1854.     int len, i, dpos, dotseen;
  1855.     int inject ();
  1856.  
  1857.     Curln = line;
  1858.  
  1859.     if (str[0] == ':')    /* text to be added is in the command line */
  1860.         ret = inject (&str[1]);
  1861.     else
  1862.     {
  1863.         Cmdrow = Toprow + (Curln - Topln) + 1;  /* 1 below Curln */
  1864.         lin[0] = EOS;
  1865.         if (Indent > 0 || line <= 0)
  1866.             len = max (0, Indent - 1);
  1867.         else /* do auto indent */
  1868.         {
  1869.             LINEDESC *k, *gettxt ();
  1870.             k = gettxt (line);
  1871.             for (len = 0; Txt[len] == ' '; len++)
  1872.                 ;
  1873.         }
  1874.         dpos = len;     /* position for terminating '.' */
  1875.  
  1876.         for (ret = NOSTATUS; ret == NOSTATUS; )
  1877.         {
  1878.             if (! hwinsdel())   /* do it the old, slow way */
  1879.             {
  1880.                 if (Cmdrow > Botrow)
  1881.                 {
  1882.                     Cmdrow = Toprow + 1;
  1883.                     cprow (Botrow, Toprow);
  1884.                     adjust_window (Curln, Curln);
  1885.                     if (First_affected > Topln)
  1886.                         First_affected = Topln;
  1887.                 }
  1888.                 clrrow (Cmdrow);
  1889.                 if (Cmdrow < Botrow)
  1890.                     clrrow (Cmdrow + 1);
  1891.             }
  1892.             else    /* try to be smart about it */
  1893.             {
  1894.                 if (Cmdrow > Botrow)
  1895.                 {
  1896.                     Cmdrow--;
  1897.                     dellines (Toprow, 1);
  1898.                     inslines (Cmdrow, 1);
  1899.                     Topln++;
  1900.                 }
  1901.                 else
  1902.                 {
  1903.                     dellines (Botrow, 1);
  1904.                     inslines (Cmdrow, 1);
  1905.                 }
  1906.             }
  1907.             prompt ("apd>");
  1908.             do
  1909.                 getcmd (lin, Firstcol, &len, &term);
  1910.             while (term == CURSOR_UP || term == CURSOR_DOWN
  1911.                 || term == CURSOR_SAME);
  1912.  
  1913.             dotseen = 0;
  1914.             if (lin[0] == '.' && lin[1] == '\n' && lin[2] == EOS)
  1915.                 dotseen = 1;
  1916.             for (i = 0; i < dpos && lin[i] == ' '; i++)
  1917.                 ;
  1918.             if (i == dpos && lin[dpos] == '.' && lin[dpos + 1] == '\n'
  1919.                 && lin[dpos+2] == EOS)
  1920.                 dotseen = 1;
  1921.  
  1922.             if (dotseen)
  1923.             {
  1924.                 if (hwinsdel())
  1925.                 {
  1926.                     dellines (Cmdrow, 1);
  1927.                     inslines (Botrow, 1);
  1928.                 }
  1929.                 ret = OK;
  1930.             }
  1931.             else if (inject (lin) == ERR)
  1932.                 ret = ERR;
  1933.             else            /* inject occured */
  1934.                 prompt ("");    /* erase prompt */
  1935.             Cmdrow++;
  1936.             if (term != FUNNY)
  1937.             {
  1938.                 if (Indent > 0)
  1939.                     len = Indent - 1;
  1940.                 else /* do auto indent */
  1941.                     for (len = 0; lin[len] == ' '; len++)
  1942.                         ;
  1943.                 dpos = len;
  1944.                 lin[0] = EOS;
  1945.             }
  1946.         }
  1947.         Cmdrow = Botrow + 1;
  1948.         if (hwinsdel())            /* since we take control */
  1949.         {                /* of the screen, we're sure */
  1950.             Sctop = Topln;        /* it's still OK */
  1951.  
  1952.             for (i = 0; i < Sclen; i++)
  1953.                 Scline[i] = Sctop + i <= Lastln ? i : -1;
  1954.         }
  1955.     }
  1956.     if (Curln == 0 && Lastln > 0)   /* for 0a or 1i followed by "." */
  1957.         Curln = 1;
  1958.     if (First_affected > line)
  1959.         First_affected = line;
  1960.  
  1961.     tflush ();
  1962.     return (ret);
  1963. }
  1964.  
  1965. /* copy --- copy line1 through line2 after line3 */
  1966.  
  1967. int copy (line3)
  1968. int line3;
  1969. {
  1970.     register int i;
  1971.     int ret;
  1972.     register LINEDESC *ptr3, *after3, *k;
  1973.     LINEDESC *getind ();
  1974.  
  1975.     ret = ERR;
  1976.  
  1977. #ifdef OLD_SCRATCH
  1978.     ptr3 = getind (line3);
  1979.     after3 = ptr3 -> Nextline;
  1980. #endif
  1981.  
  1982.     if (Line1 <= 0)
  1983.         Errcode = EORANGE;
  1984.     else
  1985.     {
  1986.         ret = OK;
  1987.         Curln = line3;
  1988.         k = getind (Line1);
  1989.         for (i = Line1; i <= Line2; i++)
  1990.         {
  1991.             gtxt (k);
  1992.             if (inject (Txt) == ERR || intrpt ())
  1993.             {
  1994.                 ret = ERR;
  1995.                 break;
  1996.             }
  1997. #ifdef OLD_SCRATCH
  1998.             if (k == ptr3)        /* make sure we don't copy stuff */
  1999.                 k = after3;    /* that's already been copied */
  2000.             else
  2001.                 k = k -> Nextline;
  2002. #else
  2003.             if (Line1 < line3)
  2004.                 k++;
  2005.             else
  2006.                 k += 2;
  2007.             /*
  2008.              * inject calls blkmove, which will shift the
  2009.              * lines down one in the array, so we add two
  2010.              * instead of one to get to the next line.
  2011.              */
  2012. #endif
  2013.         }
  2014.         First_affected = min (First_affected, line3 + 1);
  2015.     }
  2016.     return (ret);
  2017. }
  2018.  
  2019.  
  2020. /* delete --- delete lines from through to */
  2021.  
  2022. int delete (from, to, status)
  2023. int from, to, *status;
  2024. {
  2025.     int nextln (), prevln ();
  2026.     LINEDESC *k1, *k2, *j1, *j2, *l1;
  2027.     LINEDESC *getind ();
  2028.  
  2029.     if (from <= 0)          /* can't delete line 0 */
  2030.     {
  2031.         *status = ERR;
  2032.         Errcode = EORANGE;
  2033.     }
  2034.     else
  2035.     {
  2036.         if (First_affected > from)
  2037.             First_affected = from;
  2038. #ifdef OLD_SCRATCH
  2039.         k1 = getind (prevln (from));
  2040.         j1 = k1 -> Nextline;
  2041.         j2 = getind (to);
  2042.         k2 = j2 -> Nextline;
  2043.         relink (k1, k2, k1, k2);        /* close chain around deletion */
  2044. #else
  2045.         blkmove (from, to, MAXBUF - 1);    /* stick at end of buffer */
  2046. #endif
  2047.  
  2048.         Lastln -= to - from + 1;        /* adjust number of last line */
  2049.         Curln = prevln (from);
  2050.  
  2051. #ifdef OLD_SCRATCH
  2052.         if (Limbo != NOMORE)            /* discard lines in limbo */
  2053.         {
  2054.             l1 = Limbo -> Prevline;
  2055.             Limbo -> Prevline = Free;
  2056.             Free = l1;
  2057.         }
  2058. #endif
  2059.  
  2060.         Lost_lines += Limcnt;
  2061.         Limcnt = to - from + 1;        /* number of lines "deleted" */
  2062.  
  2063. #ifdef OLD_SCRATCH
  2064.         Limbo = j1;     /* put what we just deleted in limbo */
  2065.         relink (j2, j1, j2, j1);        /* close the ring */
  2066. #else
  2067.         /* point at first deleted */
  2068.         Limbo = &Buf[MAXBUF - (to - from + 1)];
  2069. #endif
  2070.         *status = OK;
  2071.         svdel (from, to - from + 1);
  2072.         Buffer_changed = YES;
  2073.     }
  2074.  
  2075.     return (*status);
  2076. }
  2077.  
  2078.  
  2079. /* join --- join a group of lines into a single line */
  2080.  
  2081. int join (sub)
  2082. char sub[];
  2083. {
  2084.     char new[MAXLINE];
  2085.     register int l, line, sublen;
  2086.     int ret;
  2087.     int inject (), delete (), prevln (), strlen ();
  2088.     register LINEDESC *k;
  2089.     LINEDESC *getind ();
  2090.  
  2091.     ret = OK;
  2092.     if (Line1 <= 0)
  2093.     {
  2094.         Errcode = EORANGE;
  2095.         return (ERR);
  2096.     }
  2097.  
  2098.     sublen = strlen (sub) + 1;      /* length of separator & EOS */
  2099.     line = Line1;
  2100.     k = getind (line);
  2101.     gtxt (k);
  2102.     move_ (Txt, new, (int) k -> Lineleng);    /* move in first chunk */
  2103.     l = k -> Lineleng;
  2104.  
  2105.     for (line++; line <= Line2; line++)
  2106.     {
  2107.         if (intrpt ())
  2108.             return (ERR);
  2109.         if (new[l - 2] == '\n') /* zap the NEWLINE */
  2110.             l--;
  2111.         k = NEXTLINE(k);    /* get the next line */
  2112.         gtxt (k);
  2113.         if (l + sublen - 1 + k -> Lineleng - 1 > MAXLINE)    /* won't fit */
  2114.         {
  2115.             Errcode = E2LONG;
  2116.             return (ERR);
  2117.         }
  2118.         move_ (sub, &new[l - 1], sublen);    /* insert separator string */
  2119.         l += sublen - 1;
  2120.         move_ (Txt, &new[l - 1], (int) k -> Lineleng);    /* move next line */
  2121.         l += k -> Lineleng - 1;
  2122.     }
  2123.     Curln = Line2;          /* all this will replace line1 through line2 */
  2124.     ret = inject (new);    /* inject the new line */
  2125.     if (ret == OK)
  2126.         ret = delete (Line1, Line2, &ret);    /* delete old lines */
  2127.     Curln++;
  2128.  
  2129.     if (First_affected > Curln)
  2130.         First_affected = Curln;
  2131.  
  2132.     return (ret);
  2133. }
  2134.  
  2135.  
  2136. /* move --- move line1 through line2 after line3 */
  2137.  
  2138. int move (line3)
  2139. int line3;
  2140. {
  2141.     int nextln (), prevln ();
  2142.     LINEDESC *k0, *k1, *k2, *k3, *k4, *k5;
  2143.     LINEDESC *getind ();
  2144.  
  2145.     if (Line1 <= 0)
  2146.     {
  2147.         Errcode = EORANGE;
  2148.         return (ERR);
  2149.     }
  2150.  
  2151.     if (Line1 <= line3 && line3 <= Line2)
  2152.     {
  2153.         Errcode = EINSIDEOUT;
  2154.         return (ERR);
  2155.     }
  2156.  
  2157. #ifdef OLD_SCRATCH
  2158.     k0 = getind (prevln (Line1));
  2159.     k1 = k0 -> Nextline;
  2160.     k2 = getind (Line2);
  2161.     k3 = k2 -> Nextline;
  2162.     relink (k0, k3, k0, k3);
  2163. #else
  2164.     blkmove (Line1, Line2, line3);
  2165. #endif
  2166.  
  2167.     if (line3 > Line1)
  2168.     {
  2169.         Curln = line3;
  2170. #ifdef OLD_SCRATCH
  2171.         line3 -= Line2 - Line1 + 1;
  2172. #endif
  2173.     }
  2174.     else
  2175.         Curln = line3 + (Line2 - Line1 + 1);
  2176.  
  2177. #ifdef OLD_SCRATCH
  2178.     k4 = getind (line3);
  2179.     k5 = k4 -> Nextline;
  2180.     relink (k4, k1, k2, k5);
  2181.     relink (k2, k5, k4, k1);
  2182. #endif
  2183.  
  2184.     Buffer_changed = YES;
  2185.     First_affected = min (First_affected, min (Line1, line3));
  2186.  
  2187.     return (OK);
  2188. }
  2189.  
  2190. /* overlay --- let user edit lines directly */
  2191.  
  2192. overlay (status)
  2193. int *status;
  2194. {
  2195.     char savtxt[MAXLINE], term, kname;
  2196.     static char empty[] = "\n";
  2197.     int lng, vcol, lcurln, scurln;
  2198.     int inject (), nextln (), prevln (), strcmp ();
  2199.     LINEDESC *indx;
  2200.     LINEDESC *getind (), *gettxt ();
  2201.  
  2202.     *status = OK;
  2203.     if (Line1 == 0)
  2204.     {
  2205.         Curln = 0;
  2206.         *status = inject (empty);
  2207.         if (*status == ERR)
  2208.             return;
  2209.         First_affected = 1;
  2210.         Line1 = 1;
  2211.         Line2++;
  2212.     }
  2213.  
  2214.     for (lcurln = Line1; lcurln <= Line2; lcurln++)
  2215.     {
  2216.         Curln = lcurln;
  2217.         vcol = Overlay_col - 1;
  2218.         do {
  2219.             adjust_window (Curln, Curln);
  2220.             updscreen ();
  2221.             Cmdrow = Curln - Topln + Toprow;
  2222.             indx = gettxt (Curln);
  2223.             lng = indx -> Lineleng;
  2224.             if (Txt[lng - 2] == '\n')       /* clobber newline */
  2225.                 lng--;
  2226.             if (vcol < 0)
  2227.                 vcol = lng - 1;
  2228.             while (lng - 1 < vcol)
  2229.             {
  2230.                 Txt[lng - 1] = ' ';
  2231.                 lng++;
  2232.             }
  2233.             Txt[lng - 1] = '\n';
  2234.             Txt[lng] = EOS;
  2235.             move_ (Txt, savtxt, lng + 1);    /* make a copy of the line */
  2236.             getcmd (Txt, Firstcol, &vcol, &term);
  2237.             if (term == FUNNY)
  2238.             {
  2239.                 if (First_affected > Curln)
  2240.                     First_affected = Curln;
  2241.                 Cmdrow = Botrow + 1;
  2242.                 return;
  2243.             }
  2244.             if (strcmp (Txt, savtxt) != 0)  /* was line changed? */
  2245.             {
  2246.                 kname = indx -> Markname;
  2247.                 delete (Curln, Curln, status);
  2248.                 scurln = Curln;
  2249.                 if (*status == OK)
  2250.                     *status = inject (Txt);
  2251.                 if (*status == ERR)
  2252.                 {
  2253.                     Cmdrow = Botrow + 1;
  2254.                     return;
  2255.                 }
  2256.                 indx = getind (nextln (scurln));
  2257.                 indx -> Markname = kname;
  2258.             }
  2259.             else
  2260.             {           /* in case end-of-line is moved */
  2261.                 if (First_affected > Curln)
  2262.                     First_affected = Curln;
  2263.             }
  2264.             switch (term) {
  2265.             case CURSOR_UP:
  2266.                 if (Curln > 1)
  2267.                     Curln--;
  2268.                 else
  2269.                     Curln = Lastln;
  2270.                 break;
  2271.             case CURSOR_DOWN:
  2272.                 if (Curln < Lastln)
  2273.                     Curln++;
  2274.                 else
  2275.                     Curln = min (1, Lastln);
  2276.                 break;
  2277.             case CURSOR_SAME:
  2278.                 vcol = 0;
  2279.                 break;
  2280.             }
  2281.         } while (term == CURSOR_UP || 
  2282.             term == CURSOR_DOWN ||
  2283.             term == CURSOR_SAME);
  2284.     }
  2285.     Cmdrow = Botrow + 1;
  2286.     return;
  2287. }
  2288.  
  2289.  
  2290. /* subst --- substitute "sub" for occurrences of pattern */
  2291.  
  2292. int subst (sub, gflag, glob)
  2293. char sub[];
  2294. int gflag, glob;
  2295. {
  2296.     char new[MAXLINE], kname;
  2297.     register int line, m, k, lastm;
  2298.     int j, junk, status, subbed, ret;
  2299.     int tagbeg[10], tagend[10];
  2300.     int amatch (), addset (), inject ();
  2301.     register LINEDESC *inx;
  2302.     LINEDESC *gettxt (), *getind ();
  2303.  
  2304.     if (Globals && glob)
  2305.         ret = OK;
  2306.     else
  2307.         ret = ERR;
  2308.  
  2309.     if (Line1 <= 0)
  2310.     {
  2311.         Errcode = EORANGE;
  2312.         return (ERR);
  2313.     }
  2314.  
  2315.     /* the following code has been removed for your protection
  2316.        index() occasionally grabs newlines out of the character class
  2317.        counter in a pattern.  for example [0-9] doesn't work due to this
  2318.  
  2319.         if (index (Pat, '\n') != -1)    # never delete NEWLINE
  2320.         {
  2321.             Errcode = EBADPAT;
  2322.             return (ERR);
  2323.         }
  2324.     */
  2325.  
  2326.     for (line = Line1; line <= Line2; line++)
  2327.     {
  2328.         if (intrpt ())
  2329.             break;
  2330.         j = 0;
  2331.         subbed = NO;
  2332.         inx = gettxt (line);
  2333.         lastm = -1;
  2334.         for (k = 0; Txt[k] != EOS; )
  2335.         {
  2336.             for (m = 1; m <= 9; m++)
  2337.             {
  2338.                 tagbeg[m] = -1;
  2339.                 tagend[m] = -1;
  2340.             }
  2341.             if (gflag == YES || subbed == NO)
  2342.                 m = amatch (Txt, k, Pat, &tagbeg[1], &tagend[1]);
  2343.             else
  2344.                 m = -1;
  2345.             if (m > -1 && lastm != m)       /* replace matched text */
  2346.             {
  2347.                 subbed = YES;
  2348.                 tagbeg[0] = k;
  2349.                 tagend[0] = m;
  2350.                 catsub (Txt, tagbeg, tagend, sub, new, &j, MAXLINE);
  2351.                 lastm = m;
  2352.             }
  2353.             if (m == -1 || m == k)  /* no match or null match */
  2354.             {
  2355.                 junk = addset (Txt[k], new, &j, MAXLINE);
  2356.                 k++;
  2357.             }
  2358.             else
  2359.                 k = m;    /* skip matched text */
  2360.         }
  2361.         if (subbed == YES)
  2362.         {
  2363.             if (addset (EOS, new, &j, MAXLINE) == NO)
  2364.             {
  2365.                 ret = ERR;
  2366.                 Errcode = E2LONG;
  2367.                 break;
  2368.             }
  2369.             kname = inx -> Markname;
  2370.             delete (line, line, &status);    /* remembers dot */
  2371.             ret = inject (new);
  2372.             if (First_affected > Curln)
  2373.                 First_affected = Curln;
  2374.             if (ret == ERR)
  2375.                 break;
  2376.             inx = getind (Curln);
  2377.             inx -> Markname = kname;
  2378.             ret = OK;
  2379.             Buffer_changed = YES;
  2380.         }
  2381.         else    /* subbed == NO */
  2382.             Errcode = ENOMATCH;
  2383.     }
  2384.  
  2385.     return (ret);
  2386. }
  2387.  
  2388.  
  2389. /* uniquely_name --- mark-name line; make sure no other line has same name */
  2390.  
  2391. uniquely_name (kname, status)
  2392. char kname;
  2393. int *status;
  2394. {
  2395.     register int line;
  2396.     register LINEDESC *k;
  2397.  
  2398.     defalt (Curln, Curln);
  2399.  
  2400.     if (Line1 <= 0)
  2401.     {
  2402.         *status = ERR;
  2403.         Errcode = EORANGE;
  2404.         return;
  2405.     }
  2406.  
  2407.     *status = OK;
  2408.     line = 0;
  2409.     k = Line0;
  2410.  
  2411.     do {
  2412.         line++;
  2413.         k = NEXTLINE(k);
  2414.         if (line == Line2)
  2415.             k -> Markname = kname;
  2416.         else if (k -> Markname == kname)
  2417.             k -> Markname = DEFAULTNAME;
  2418.     } while (line < Lastln);
  2419.  
  2420.     return;
  2421. }
  2422.  
  2423.  
  2424. /* draw_box --- draw or erase a box at coordinates in command line */
  2425.  
  2426. int draw_box (lin, i)
  2427. char lin[];
  2428. int *i;
  2429. {
  2430.     register int left, right, col, len;
  2431.     int junk;
  2432.     int ctoi (), strcmp (), inject (), delete ();
  2433.     register LINEDESC *k;
  2434.     LINEDESC *getind (), *gettxt ();
  2435.     char text[MAXLINE];
  2436.     char kname, ch;
  2437.  
  2438.     left = ctoi (lin, i);
  2439.     if (left <= 0 || left > MAXLINE)
  2440.     {
  2441.         Errcode = EBADCOL;
  2442.         return (ERR);
  2443.     }
  2444.  
  2445.     if (lin[*i] == ',')
  2446.     {
  2447.         (*i)++;
  2448.         SKIPBL (lin, *i);
  2449.         right = ctoi (lin, i);
  2450.         if (right <= 0 || right >= MAXLINE || left > right)
  2451.         {
  2452.             Errcode = EBADCOL;
  2453.             return (ERR);
  2454.         }
  2455.     }
  2456.     else
  2457.         right = left;
  2458.  
  2459.     SKIPBL (lin, *i);
  2460.     if (lin[*i] == '\n')
  2461.         ch = ' ';
  2462.     else
  2463.         ch = lin[(*i)++];
  2464.  
  2465.     if (lin[*i] != '\n')
  2466.     {
  2467.         Errcode = EEGARB;
  2468.         return (ERR);
  2469.     }
  2470.  
  2471.     if (Line1 <= 0)
  2472.     {
  2473.         Errcode = EORANGE;
  2474.         return (ERR);
  2475.     }
  2476.  
  2477.     for (Curln = Line1; Curln <= Line2; Curln++)
  2478.     {
  2479.         k = gettxt (Curln);
  2480.         len = k -> Lineleng;
  2481.         move_ (Txt, text, len);
  2482.  
  2483.         if (text[len - 2] == '\n')
  2484.             col = len - 1;
  2485.         else
  2486.             col = len;
  2487.         while (col <= right)
  2488.         {
  2489.             text[col - 1] = ' ';
  2490.             col++;
  2491.         }
  2492.         text[col - 1] = '\n';
  2493.         text[col] = EOS;
  2494.  
  2495.         if (Curln == Line1 || Curln == Line2)
  2496.             for (col = left; col <= right; col++)
  2497.                 text[col - 1] = ch;
  2498.         else
  2499.         {
  2500.             text[left - 1] = ch;
  2501.             text[right - 1] = ch;
  2502.         }
  2503.  
  2504.         if (strcmp (text, Txt) != 0)
  2505.         {
  2506.             kname = k -> Markname;
  2507.             if (delete (Curln, Curln, &junk) == ERR
  2508.                 || inject (text) == ERR)
  2509.                 return (ERR);
  2510.             k = getind (Curln);
  2511.             k -> Markname = kname;
  2512.             Buffer_changed = YES;
  2513.         }
  2514.     }
  2515.  
  2516.     Curln = Line1;        /* move to top of box */
  2517.     if (First_affected > Curln)
  2518.         First_affected = Curln;
  2519.     adjust_window (Curln, Curln);
  2520.     updscreen ();
  2521.  
  2522.     return (OK);
  2523. }
  2524.  
  2525.  
  2526. /* dfltsopt --- set the 's' option to the extension on the file name */
  2527.  
  2528. dfltsopt (name)
  2529. char name[];
  2530. {
  2531.     int i;
  2532.     int strlen (), dosopt ();
  2533.  
  2534.     for (i = strlen (name) - 1; i >= 0; i--)
  2535.         if (name[i] == '.')
  2536.         {
  2537.             dosopt (&name[i + 1]);
  2538.             break;
  2539.         }
  2540.     if (i < 0)
  2541.         dosopt ("");
  2542. }
  2543.  
  2544.  
  2545.  
  2546. /* doshell --- escape to the Shell to run one or more Unix commands */
  2547.  
  2548. /*
  2549. ** emulate vi: if running just a shell, redraw the screen as
  2550. ** soon as the shell exits. if running a program, let the user
  2551. ** redraw the screen when he/she is ready.
  2552. **
  2553. ** also emulate USG Unix 5.0 ed: a ! as the first character is
  2554. ** replaced by the previous shell command; an unescaped % is replaced
  2555. ** by the saved file name. The expanded command is echoed.
  2556. */
  2557.  
  2558. #ifdef BSD
  2559. #define DEFAULT_PATH    "/bin/csh"
  2560. #define DEF_SHELL    "csh"
  2561. #else
  2562. #define DEFAULT_PATH    "/bin/sh"
  2563. #define DEF_SHELL    "sh"
  2564. #endif
  2565.  
  2566. int doshell (lin, pi)
  2567. char lin[];
  2568. int *pi;
  2569. {
  2570.     int forkstatus, childstatus;
  2571.     int (*save_quit)(), (*save_int)();
  2572.     int int_hdlr ();
  2573.     int (*signal())();
  2574.     int i, auto_redraw;
  2575.     char *path, *name, *p, *getenv ();
  2576.     char new_command[MAXLINE];
  2577.     int j, k;
  2578.     static char sav_com[MAXLINE] = "";
  2579.     int expanded = NO;
  2580.  
  2581.     if (Nlines == 0)        /* use normal 'ed' behavior */
  2582.     {
  2583.         tflush ();    /* flush out the terminal output */
  2584.         position_cursor (Nrows - 1, 0);    /* bottom left corner */
  2585.  
  2586.         if ((p = getenv ("SHELL")) == NULL || strcmp (p, DEFAULT_PATH) == 0)
  2587.         {
  2588.             path = DEFAULT_PATH;
  2589.             name = DEF_SHELL;    /* default */
  2590.         }
  2591. #ifdef BSD
  2592.         /* on Berkeley systems, check the other shell */
  2593.         else if (strcmp (p, "/bin/sh") == 0)
  2594.         {
  2595.             path = "/bin/sh";
  2596.             name = "sh";
  2597.         }
  2598. #endif
  2599.         else
  2600.         {
  2601.             if (p[0] == '/')    /* full pathname there */
  2602.             {
  2603.                 /* work backwards to find just name */
  2604.                 path = p;
  2605.                 i = strlen (p);
  2606.                 while (p[i] != '/')
  2607.                     i--;
  2608.                 i++;        /* skip '/' */
  2609.                 name = &p[i];
  2610.             }
  2611.             else
  2612.             {
  2613.                 char buf[MAXLINE];
  2614.  
  2615.                 sprintf (buf, "unknown shell, using %s",
  2616.                     DEF_SHELL);
  2617.                 remark (buf);
  2618.                 path = DEFAULT_PATH;
  2619.                 name = DEF_SHELL;
  2620.             }
  2621.         }
  2622.  
  2623.         auto_redraw = (lin[*pi] == '\n') ? YES : NO;
  2624.  
  2625.         /* build command, checking for leading !, and % anywhere */
  2626.         if (lin[*pi] == '!')
  2627.         {
  2628.             if (sav_com[0] != EOS)
  2629.             {
  2630.                 for (j = 0; sav_com[j] != EOS; j++)
  2631.                     new_command[j] = sav_com[j];
  2632.                 if (new_command[j-1] == '\n')
  2633.                     j--;
  2634.                 (*pi)++;
  2635.                 expanded = YES;
  2636.             }
  2637.             else
  2638.             {
  2639.                 Errcode = ENOCMD;
  2640.                 return (ERR);
  2641.             }
  2642.         }
  2643.         else
  2644.             j = 0;
  2645.  
  2646.         for (i = *pi; lin[i] != EOS; i++)
  2647.         {
  2648.             if (lin[i] == ESCAPE)
  2649.             {
  2650.                 if (lin[i+1] != '%')
  2651.                 {
  2652.                     new_command[j++] = ESCAPE;
  2653.                     new_command[j++] = lin[++i];
  2654.                 }
  2655.                 else
  2656.                     new_command[j++] = lin[++i];
  2657.             }
  2658.             else if (lin[i] == '%')
  2659.             {
  2660.                 for (k = 0; Savfil[k] != EOS; k++)
  2661.                     new_command[j++] = Savfil[k];
  2662.                 expanded = YES;
  2663.             }
  2664.             else
  2665.                 new_command[j++] = lin[i];
  2666.         }
  2667.  
  2668.         if (new_command[j-1] == '\n')
  2669.             j--;
  2670.         new_command[j] = EOS;
  2671.  
  2672.         strcpy (sav_com, new_command);    /* save it */
  2673.  
  2674.         ttynormal ();
  2675. #ifndef HARD_TERMS
  2676.         t_exit ();
  2677. #endif
  2678.         write (1, "\n\n", 2);            /* clear out a line */
  2679.  
  2680.         forkstatus = fork();
  2681.         if (forkstatus == -1)   /* the fork failed */
  2682.         {
  2683.             ttyedit ();
  2684. #ifndef HARD_TERMS
  2685.             t_init ();
  2686. #endif
  2687.             Errcode = ECANTFORK;
  2688.             return ERR;
  2689.         }
  2690.  
  2691.         if (forkstatus == 0)    /* we're in the child process */
  2692.         {
  2693.             signal (SIGINT, SIG_DFL);
  2694.             signal (SIGQUIT, SIG_DFL);
  2695. #ifdef BSD
  2696.             if (strcmp (name, "sh") != 0)    /* not /bin/sh */
  2697.                 signal (SIGTSTP, SIG_DFL);
  2698.             else
  2699.                 signal (SIGTSTP, SIG_IGN);
  2700. #endif
  2701.             if (auto_redraw)    /* no params; run a shell */
  2702.             {
  2703.                 execl (path, name, 0);
  2704.                 _exit (RETERR);   /* exec failed, notify parent */
  2705.             }
  2706.             else
  2707.             {
  2708.                 if (expanded)        /* echo it */
  2709.                     printf ("%s\n", new_command);
  2710.  
  2711.                 execl (path, name, "-c", new_command, 0);
  2712.                 _exit (RETERR);
  2713.             }
  2714.         }
  2715.  
  2716.         /* we're in the parent process here */
  2717.         save_int = signal (SIGINT, SIG_IGN);        /* ignore interrupts */
  2718.         save_quit = signal (SIGQUIT, SIG_IGN);
  2719.         while (wait (&childstatus) != forkstatus)
  2720.             ;
  2721.         save_int = signal (SIGINT, save_int);       /* catch interupts */
  2722.         save_quit = signal (SIGQUIT, save_quit);
  2723.         write (1, "\n\n", 2);    /* clear out some message space */
  2724.         Currow = Nrows - 1;
  2725.         Curcol = 0;
  2726.         if ((childstatus >> 8) != 0)
  2727.         {
  2728.             ttyedit ();
  2729. #ifndef HARD_TERMS
  2730.             t_init ();
  2731. #endif
  2732.             Errcode = ENOSHELL;
  2733.             return ERR;
  2734.         }
  2735.  
  2736.         /* a la vi: */
  2737.         if (! auto_redraw)
  2738.         {
  2739.             int c;
  2740.  
  2741.             printf ("type return to continue: ");
  2742.             while ((c = getchar()) != '\n' && c != EOF)
  2743.                 ;
  2744.         }
  2745.  
  2746.         ttyedit ();
  2747. #ifndef HARD_TERMS
  2748.         t_init ();
  2749. #endif
  2750.         restore_screen ();
  2751.  
  2752.         return OK;
  2753.     }
  2754.  
  2755.     else
  2756.         remark ("Not implemented yet");
  2757.     
  2758.     return OK;
  2759. }
  2760. SHAR_EOF
  2761. fi # end of overwriting check
  2762. #    End of shell archive
  2763. exit 0
  2764.  
  2765.